const path = require('path');
const OSUtils = require('./osUtils');

/**
 * 路径工具类
 * 提供跨平台的路径处理功能
 */
class PathUtils {
  /**
   * 规范化路径，确保跨平台兼容性
   * @param {string} inputPath 输入路径
   * @returns {string} 规范化后的路径
   */
  static normalize(inputPath) {
    if (!inputPath) return '';
    return path.normalize(inputPath);
  }

  /**
   * 连接路径片段
   * @param {...string} segments 路径片段
   * @returns {string} 连接后的路径
   */
  static join(...segments) {
    return path.join(...segments);
  }

  /**
   * 解析为绝对路径
   * @param {...string} segments 路径片段
   * @returns {string} 绝对路径
   */
  static resolve(...segments) {
    return path.resolve(...segments);
  }

  /**
   * 获取路径的目录名
   * @param {string} filePath 文件路径
   * @returns {string} 目录名
   */
  static dirname(filePath) {
    return path.dirname(filePath);
  }

  /**
   * 获取路径的基础名（文件名）
   * @param {string} filePath 文件路径
   * @param {string} ext 可选的扩展名
   * @returns {string} 基础名
   */
  static basename(filePath, ext) {
    return path.basename(filePath, ext);
  }

  /**
   * 获取文件扩展名
   * @param {string} filePath 文件路径
   * @returns {string} 扩展名
   */
  static extname(filePath) {
    return path.extname(filePath);
  }

  /**
   * 检查路径是否为绝对路径
   * @param {string} inputPath 输入路径
   * @returns {boolean} 是否为绝对路径
   */
  static isAbsolute(inputPath) {
    return path.isAbsolute(inputPath);
  }

  /**
   * 获取相对路径
   * @param {string} from 起始路径
   * @param {string} to 目标路径
   * @returns {string} 相对路径
   */
  static relative(from, to) {
    return path.relative(from, to);
  }

  // 获取路径分隔符
  static getPathSeparator() {
    return path.sep;
  }

  /**
   * 确保路径使用正确的分隔符
   * @param {string} inputPath 输入路径
   * @returns {string} 使用正确分隔符的路径
   */
  static fixSeparators(inputPath) {
    if (!inputPath) return '';
    
    if (OSUtils.isWindows()) {
      // Windows: 将正斜杠转换为反斜杠
      return inputPath.replace(/\//g, '\\');
    } else {
      // Unix: 将反斜杠转换为正斜杠
      return inputPath.replace(/\\/g, '/');
    }
  }

  /**
   * 创建安全的路径（防止路径遍历攻击）
   * @param {string} basePath 基础路径
   * @param {string} userPath 用户提供的路径
   * @returns {string} 安全的路径
   */
  static createSafePath(basePath, userPath) {
    const normalizedBase = this.resolve(basePath);
    const normalizedUser = this.normalize(userPath);
    const fullPath = this.resolve(normalizedBase, normalizedUser);
    
    // 确保结果路径在基础路径内
    if (!fullPath.startsWith(normalizedBase)) {
      throw new Error('路径遍历攻击检测：不允许访问基础路径之外的文件');
    }
    
    return fullPath;
  }

  /**
   * 获取项目根目录
   * @returns {string} 项目根目录路径
   */
  static getProjectRoot() {
    return this.resolve(__dirname, '..');
  }

  /**
   * 获取数据目录路径
   * @returns {string} 数据目录路径
   */
  static getDataDir() {
    return this.join(this.getProjectRoot(), 'data');
  }

  /**
   * 获取日志目录路径
   * @returns {string} 日志目录路径
   */
  static getLogsDir() {
    return this.join(this.getProjectRoot(), 'logs');
  }

  /**
   * 获取临时目录路径
   * @returns {string} 临时目录路径
   */
  static getTempDir() {
    return this.join(this.getProjectRoot(), 'temp');
  }

  /**
   * 获取配置文件路径
   * @param {string} configName 配置文件名
   * @returns {string} 配置文件路径
   */
  static getConfigPath(configName = 'default.json') {
    return this.join(this.getProjectRoot(), 'config', configName);
  }

  /**
   * 解析相对于项目根目录的路径
   * @param {string} relativePath 相对路径
   * @returns {string} 绝对路径
   */
  static resolveFromRoot(relativePath) {
    if (this.isAbsolute(relativePath)) {
      return relativePath;
    }
    return this.resolve(this.getProjectRoot(), relativePath);
  }

  /**
   * 确保目录路径以分隔符结尾
   * @param {string} dirPath 目录路径
   * @returns {string} 以分隔符结尾的目录路径
   */
  static ensureTrailingSeparator(dirPath) {
    if (!dirPath) return '';
    const normalized = this.normalize(dirPath);
    const separator = path.sep;
    return normalized.endsWith(separator) ? normalized : normalized + separator;
  }

  /**
   * 移除路径末尾的分隔符
   * @param {string} dirPath 目录路径
   * @returns {string} 移除末尾分隔符的路径
   */
  static removeTrailingSeparator(dirPath) {
    if (!dirPath) return '';
    const normalized = this.normalize(dirPath);
    const separator = path.sep;
    return normalized.endsWith(separator) ? normalized.slice(0, -1) : normalized;
  }

  /**
   * 将配置中的路径转换为绝对路径
   * @param {string} configPath 配置中的路径
   * @returns {string} 绝对路径
   */
  static resolveConfigPath(configPath) {
    if (!configPath) return '';
    
    // 如果已经是绝对路径，直接返回
    if (this.isAbsolute(configPath)) {
      return this.normalize(configPath);
    }
    
    // 相对路径，相对于项目根目录解析
    return this.resolveFromRoot(configPath);
  }
}

module.exports = PathUtils;